

<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="Description" content="scikit-learn: machine learning in Python">

  
  <title>sklearn.impute.IterativeImputer &mdash; scikit-learn 0.22 documentation</title>
  
  <link rel="canonical" href="http://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html" />

  
  <link rel="shortcut icon" href="../../_static/favicon.ico"/>
  

  <link rel="stylesheet" href="../../_static/css/vendor/bootstrap.min.css" type="text/css" />
  <link rel="stylesheet" href="../../_static/gallery.css" type="text/css" />
  <link rel="stylesheet" href="../../_static/css/theme.css" type="text/css" />
<script id="documentation_options" data-url_root="../../" src="../../_static/documentation_options.js"></script>
<script src="../../_static/jquery.js"></script> 
</head>
<body>
<nav id="navbar" class="sk-docs-navbar navbar navbar-expand-md navbar-light bg-light py-0">
  <div class="container-fluid sk-docs-container px-0">
      <a class="navbar-brand py-0" href="../../index.html">
        <img
          class="sk-brand-img"
          src="../../_static/scikit-learn-logo-small.png"
          alt="logo"/>
      </a>
    <button
      id="sk-navbar-toggler"
      class="navbar-toggler"
      type="button"
      data-toggle="collapse"
      data-target="#navbarSupportedContent"
      aria-controls="navbarSupportedContent"
      aria-expanded="false"
      aria-label="Toggle navigation"
    >
      <span class="navbar-toggler-icon"></span>
    </button>

    <div class="sk-navbar-collapse collapse navbar-collapse" id="navbarSupportedContent">
      <ul class="navbar-nav mr-auto">
        <li class="nav-item">
          <a class="sk-nav-link nav-link" href="../../install.html">Install</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link" href="../../user_guide.html">User Guide</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link" href="../classes.html">API</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link" href="../../auto_examples/index.html">Examples</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="../../getting_started.html">Getting Started</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="../../tutorial/index.html">Tutorial</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="../../glossary.html">Glossary</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="../../developers/index.html">Development</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="../../faq.html">FAQ</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="../../related_projects.html">Related packages</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="../../roadmap.html">Roadmap</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="../../about.html">About us</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="https://github.com/scikit-learn/scikit-learn">GitHub</a>
        </li>
        <li class="nav-item">
          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="https://scikit-learn.org/dev/versions.html">Other Versions</a>
        </li>
        <li class="nav-item dropdown nav-more-item-dropdown">
          <a class="sk-nav-link nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">More</a>
          <div class="dropdown-menu" aria-labelledby="navbarDropdown">
              <a class="sk-nav-dropdown-item dropdown-item" href="../../getting_started.html">Getting Started</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="../../tutorial/index.html">Tutorial</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="../../glossary.html">Glossary</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="../../developers/index.html">Development</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="../../faq.html">FAQ</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="../../related_projects.html">Related packages</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="../../roadmap.html">Roadmap</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="../../about.html">About us</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="https://github.com/scikit-learn/scikit-learn">GitHub</a>
              <a class="sk-nav-dropdown-item dropdown-item" href="https://scikit-learn.org/dev/versions.html">Other Versions</a>
          </div>
        </li>
      </ul>
      <div id="searchbox" role="search">
          <div class="searchformwrapper">
          <form class="search" action="../../search.html" method="get">
            <input class="sk-search-text-input" type="text" name="q" aria-labelledby="searchlabel" />
            <input class="sk-search-text-btn" type="submit" value="Go" />
          </form>
          </div>
      </div>
    </div>
  </div>
</nav>
<div class="d-flex" id="sk-doc-wrapper">
    <input type="checkbox" name="sk-toggle-checkbox" id="sk-toggle-checkbox">
    <label id="sk-sidemenu-toggle" class="sk-btn-toggle-toc btn sk-btn-primary" for="sk-toggle-checkbox">Toggle Menu</label>
    <div id="sk-sidebar-wrapper" class="border-right">
      <div class="sk-sidebar-toc-wrapper">
        <div class="sk-sidebar-toc-logo">
          <a href="../../index.html">
            <img
              class="sk-brand-img"
              src="../../_static/scikit-learn-logo-small.png"
              alt="logo"/>
          </a>
        </div>
        <div class="btn-group w-100 mb-2" role="group" aria-label="rellinks">
            <a href="sklearn.impute.SimpleImputer.html" role="button" class="btn sk-btn-rellink py-1" sk-rellink-tooltip="sklearn.impute.SimpleImputer">Prev</a><a href="../classes.html" role="button" class="btn sk-btn-rellink py-1" sk-rellink-tooltip="API Reference">Up</a>
            <a href="sklearn.impute.MissingIndicator.html" role="button" class="btn sk-btn-rellink py-1" sk-rellink-tooltip="sklearn.impute.MissingIndicator">Next</a>
        </div>
        <div class="alert alert-danger p-1 mb-2" role="alert">
          <p class="text-center mb-0">
          <strong>scikit-learn 0.22</strong><br/>
          <a href="http://scikit-learn.org/dev/versions.html">Other versions</a>
          </p>
        </div>
        <div class="alert alert-warning p-1 mb-2" role="alert">
          <p class="text-center mb-0">
            Please <a class="font-weight-bold" href="../../about.html#citing-scikit-learn"><string>cite us</string></a> if you use the software.
          </p>
        </div>
          <div class="sk-sidebar-toc">
            <ul>
<li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">sklearn.impute</span></code>.IterativeImputer</a><ul>
<li><a class="reference internal" href="#examples-using-sklearn-impute-iterativeimputer">Examples using <code class="docutils literal notranslate"><span class="pre">sklearn.impute.IterativeImputer</span></code></a></li>
</ul>
</li>
</ul>

          </div>
      </div>
    </div>
    <div id="sk-page-content-wrapper">
      <div class="sk-page-content container-fluid body px-md-3" role="main">
        
  <div class="section" id="sklearn-impute-iterativeimputer">
<h1><a class="reference internal" href="../classes.html#module-sklearn.impute" title="sklearn.impute"><code class="xref py py-mod docutils literal notranslate"><span class="pre">sklearn.impute</span></code></a>.IterativeImputer<a class="headerlink" href="#sklearn-impute-iterativeimputer" title="Permalink to this headline">¶</a></h1>
<dl class="class">
<dt id="sklearn.impute.IterativeImputer">
<em class="property">class </em><code class="sig-prename descclassname">sklearn.impute.</code><code class="sig-name descname">IterativeImputer</code><span class="sig-paren">(</span><em class="sig-param">estimator=None</em>, <em class="sig-param">missing_values=nan</em>, <em class="sig-param">sample_posterior=False</em>, <em class="sig-param">max_iter=10</em>, <em class="sig-param">tol=0.001</em>, <em class="sig-param">n_nearest_features=None</em>, <em class="sig-param">initial_strategy='mean'</em>, <em class="sig-param">imputation_order='ascending'</em>, <em class="sig-param">skip_complete=False</em>, <em class="sig-param">min_value=None</em>, <em class="sig-param">max_value=None</em>, <em class="sig-param">verbose=0</em>, <em class="sig-param">random_state=None</em>, <em class="sig-param">add_indicator=False</em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/scikit-learn/scikit-learn/blob/5f3c3f037/sklearn/impute/_iterative.py#L29"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#sklearn.impute.IterativeImputer" title="Permalink to this definition">¶</a></dt>
<dd><p>Multivariate imputer that estimates each feature from all the others.</p>
<p>A strategy for imputing missing values by modeling each feature with
missing values as a function of other features in a round-robin fashion.</p>
<p>Read more in the <a class="reference internal" href="../impute.html#iterative-imputer"><span class="std std-ref">User Guide</span></a>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This estimator is still <strong>experimental</strong> for now: the predictions
and the API might change without any deprecation cycle. To use it,
you need to explicitly import <code class="docutils literal notranslate"><span class="pre">enable_iterative_imputer</span></code>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># explicitly require this experimental feature</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sklearn.experimental</span> <span class="kn">import</span> <span class="n">enable_iterative_imputer</span>  <span class="c1"># noqa</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># now you can import normally from sklearn.impute</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sklearn.impute</span> <span class="kn">import</span> <span class="n">IterativeImputer</span>
</pre></div>
</div>
</div>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><dl>
<dt><strong>estimator</strong><span class="classifier">estimator object, default=BayesianRidge()</span></dt><dd><p>The estimator to use at each step of the round-robin imputation.
If <code class="docutils literal notranslate"><span class="pre">sample_posterior</span></code> is True, the estimator must support
<code class="docutils literal notranslate"><span class="pre">return_std</span></code> in its <code class="docutils literal notranslate"><span class="pre">predict</span></code> method.</p>
</dd>
<dt><strong>missing_values</strong><span class="classifier">int, np.nan, optional (default=np.nan)</span></dt><dd><p>The placeholder for the missing values. All occurrences of
<code class="docutils literal notranslate"><span class="pre">missing_values</span></code> will be imputed.</p>
</dd>
<dt><strong>sample_posterior</strong><span class="classifier">boolean, default=False</span></dt><dd><p>Whether to sample from the (Gaussian) predictive posterior of the
fitted estimator for each imputation. Estimator must support
<code class="docutils literal notranslate"><span class="pre">return_std</span></code> in its <code class="docutils literal notranslate"><span class="pre">predict</span></code> method if set to <code class="docutils literal notranslate"><span class="pre">True</span></code>. Set to
<code class="docutils literal notranslate"><span class="pre">True</span></code> if using <code class="docutils literal notranslate"><span class="pre">IterativeImputer</span></code> for multiple imputations.</p>
</dd>
<dt><strong>max_iter</strong><span class="classifier">int, optional (default=10)</span></dt><dd><p>Maximum number of imputation rounds to perform before returning the
imputations computed during the final round. A round is a single
imputation of each feature with missing values. The stopping criterion
is met once <code class="docutils literal notranslate"><span class="pre">abs(max(X_t</span> <span class="pre">-</span> <span class="pre">X_{t-1}))/abs(max(X[known_vals]))</span></code> &lt; tol,
where <code class="docutils literal notranslate"><span class="pre">X_t</span></code> is <code class="docutils literal notranslate"><span class="pre">X</span></code> at iteration <code class="docutils literal notranslate"><span class="pre">t.</span> <span class="pre">Note</span> <span class="pre">that</span> <span class="pre">early</span> <span class="pre">stopping</span> <span class="pre">is</span> <span class="pre">only</span>
<span class="pre">applied</span> <span class="pre">if</span> <span class="pre">``sample_posterior=False`</span></code>.</p>
</dd>
<dt><strong>tol</strong><span class="classifier">float, optional (default=1e-3)</span></dt><dd><p>Tolerance of the stopping condition.</p>
</dd>
<dt><strong>n_nearest_features</strong><span class="classifier">int, optional (default=None)</span></dt><dd><p>Number of other features to use to estimate the missing values of
each feature column. Nearness between features is measured using
the absolute correlation coefficient between each feature pair (after
initial imputation). To ensure coverage of features throughout the
imputation process, the neighbor features are not necessarily nearest,
but are drawn with probability proportional to correlation for each
imputed target feature. Can provide significant speed-up when the
number of features is huge. If <code class="docutils literal notranslate"><span class="pre">None</span></code>, all features will be used.</p>
</dd>
<dt><strong>initial_strategy</strong><span class="classifier">str, optional (default=”mean”)</span></dt><dd><p>Which strategy to use to initialize the missing values. Same as the
<code class="docutils literal notranslate"><span class="pre">strategy</span></code> parameter in <a class="reference internal" href="sklearn.impute.SimpleImputer.html#sklearn.impute.SimpleImputer" title="sklearn.impute.SimpleImputer"><code class="xref py py-class docutils literal notranslate"><span class="pre">sklearn.impute.SimpleImputer</span></code></a>
Valid values: {“mean”, “median”, “most_frequent”, or “constant”}.</p>
</dd>
<dt><strong>imputation_order</strong><span class="classifier">str, optional (default=”ascending”)</span></dt><dd><p>The order in which the features will be imputed. Possible values:</p>
<dl class="simple">
<dt>“ascending”</dt><dd><p>From features with fewest missing values to most.</p>
</dd>
<dt>“descending”</dt><dd><p>From features with most missing values to fewest.</p>
</dd>
<dt>“roman”</dt><dd><p>Left to right.</p>
</dd>
<dt>“arabic”</dt><dd><p>Right to left.</p>
</dd>
<dt>“random”</dt><dd><p>A random order for each round.</p>
</dd>
</dl>
</dd>
<dt><strong>skip_complete</strong><span class="classifier">boolean, optional (default=False)</span></dt><dd><p>If <code class="docutils literal notranslate"><span class="pre">True</span></code> then features with missing values during <code class="docutils literal notranslate"><span class="pre">transform</span></code>
which did not have any missing values during <code class="docutils literal notranslate"><span class="pre">fit</span></code> will be imputed
with the initial imputation method only. Set to <code class="docutils literal notranslate"><span class="pre">True</span></code> if you have
many features with no missing values at both <code class="docutils literal notranslate"><span class="pre">fit</span></code> and <code class="docutils literal notranslate"><span class="pre">transform</span></code>
time to save compute.</p>
</dd>
<dt><strong>min_value</strong><span class="classifier">float, optional (default=None)</span></dt><dd><p>Minimum possible imputed value. Default of <code class="docutils literal notranslate"><span class="pre">None</span></code> will set minimum
to negative infinity.</p>
</dd>
<dt><strong>max_value</strong><span class="classifier">float, optional (default=None)</span></dt><dd><p>Maximum possible imputed value. Default of <code class="docutils literal notranslate"><span class="pre">None</span></code> will set maximum
to positive infinity.</p>
</dd>
<dt><strong>verbose</strong><span class="classifier">int, optional (default=0)</span></dt><dd><p>Verbosity flag, controls the debug messages that are issued
as functions are evaluated. The higher, the more verbose. Can be 0, 1,
or 2.</p>
</dd>
<dt><strong>random_state</strong><span class="classifier">int, RandomState instance or None, optional (default=None)</span></dt><dd><p>The seed of the pseudo random number generator to use. Randomizes
selection of estimator features if n_nearest_features is not None, the
<code class="docutils literal notranslate"><span class="pre">imputation_order</span></code> if <code class="docutils literal notranslate"><span class="pre">random</span></code>, and the sampling from posterior if
<code class="docutils literal notranslate"><span class="pre">sample_posterior</span></code> is True. Use an integer for determinism.
See <a class="reference internal" href="../../glossary.html#term-random-state"><span class="xref std std-term">the Glossary</span></a>.</p>
</dd>
<dt><strong>add_indicator</strong><span class="classifier">boolean, optional (default=False)</span></dt><dd><p>If True, a <a class="reference internal" href="sklearn.impute.MissingIndicator.html#sklearn.impute.MissingIndicator" title="sklearn.impute.MissingIndicator"><code class="xref py py-class docutils literal notranslate"><span class="pre">MissingIndicator</span></code></a> transform will stack onto output
of the imputer’s transform. This allows a predictive estimator
to account for missingness despite imputation. If a feature has no
missing values at fit/train time, the feature won’t appear on
the missing indicator even if there are missing values at
transform/test time.</p>
</dd>
</dl>
</dd>
<dt class="field-even">Attributes</dt>
<dd class="field-even"><dl>
<dt><strong>initial_imputer_</strong><span class="classifier">object of type <a class="reference internal" href="sklearn.impute.SimpleImputer.html#sklearn.impute.SimpleImputer" title="sklearn.impute.SimpleImputer"><code class="xref py py-class docutils literal notranslate"><span class="pre">sklearn.impute.SimpleImputer</span></code></a></span></dt><dd><p>Imputer used to initialize the missing values.</p>
</dd>
<dt><strong>imputation_sequence_</strong><span class="classifier">list of tuples</span></dt><dd><p>Each tuple has <code class="docutils literal notranslate"><span class="pre">(feat_idx,</span> <span class="pre">neighbor_feat_idx,</span> <span class="pre">estimator)</span></code>, where
<code class="docutils literal notranslate"><span class="pre">feat_idx</span></code> is the current feature to be imputed,
<code class="docutils literal notranslate"><span class="pre">neighbor_feat_idx</span></code> is the array of other features used to impute the
current feature, and <code class="docutils literal notranslate"><span class="pre">estimator</span></code> is the trained estimator used for
the imputation. Length is <code class="docutils literal notranslate"><span class="pre">self.n_features_with_missing_</span> <span class="pre">*</span>
<span class="pre">self.n_iter_</span></code>.</p>
</dd>
<dt><strong>n_iter_</strong><span class="classifier">int</span></dt><dd><p>Number of iteration rounds that occurred. Will be less than
<code class="docutils literal notranslate"><span class="pre">self.max_iter</span></code> if early stopping criterion was reached.</p>
</dd>
<dt><strong>n_features_with_missing_</strong><span class="classifier">int</span></dt><dd><p>Number of features with missing values.</p>
</dd>
<dt><strong>indicator_</strong><span class="classifier"><a class="reference internal" href="sklearn.impute.MissingIndicator.html#sklearn.impute.MissingIndicator" title="sklearn.impute.MissingIndicator"><code class="xref py py-class docutils literal notranslate"><span class="pre">sklearn.impute.MissingIndicator</span></code></a></span></dt><dd><p>Indicator used to add binary indicators for missing values.
<code class="docutils literal notranslate"><span class="pre">None</span></code> if add_indicator is False.</p>
</dd>
<dt><strong>random_state_</strong><span class="classifier">RandomState instance</span></dt><dd><p>RandomState instance that is generated either from a seed, the random
number generator or by <code class="docutils literal notranslate"><span class="pre">np.random</span></code>.</p>
</dd>
</dl>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<dl class="simple">
<dt><a class="reference internal" href="sklearn.impute.SimpleImputer.html#sklearn.impute.SimpleImputer" title="sklearn.impute.SimpleImputer"><code class="xref py py-obj docutils literal notranslate"><span class="pre">SimpleImputer</span></code></a></dt><dd><p>Univariate imputation of missing values.</p>
</dd>
</dl>
</div>
<p class="rubric">Notes</p>
<p>To support imputation in inductive mode we store each feature’s estimator
during the <code class="docutils literal notranslate"><span class="pre">fit</span></code> phase, and predict without refitting (in order) during
the <code class="docutils literal notranslate"><span class="pre">transform</span></code> phase.</p>
<p>Features which contain all missing values at <code class="docutils literal notranslate"><span class="pre">fit</span></code> are discarded upon
<code class="docutils literal notranslate"><span class="pre">transform</span></code>.</p>
<p class="rubric">References</p>
<dl class="citation">
<dt class="label" id="rcd31b817a31e-1"><span class="brackets">Rcd31b817a31e-1</span></dt>
<dd><p><a class="reference external" href="https://www.jstatsoft.org/article/view/v045i03">Stef van Buuren, Karin Groothuis-Oudshoorn (2011). “mice:
Multivariate Imputation by Chained Equations in R”. Journal of
Statistical Software 45: 1-67.</a></p>
</dd>
<dt class="label" id="rcd31b817a31e-2"><span class="brackets">Rcd31b817a31e-2</span></dt>
<dd><p><a class="reference external" href="https://www.jstor.org/stable/2984099">S. F. Buck, (1960). “A Method of Estimation of Missing Values in
Multivariate Data Suitable for use with an Electronic Computer”.
Journal of the Royal Statistical Society 22(2): 302-306.</a></p>
</dd>
</dl>
<p class="rubric">Examples</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sklearn.experimental</span> <span class="kn">import</span> <span class="n">enable_iterative_imputer</span>  
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sklearn.impute</span> <span class="kn">import</span> <span class="n">IterativeImputer</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">imp_mean</span> <span class="o">=</span> <span class="n">IterativeImputer</span><span class="p">(</span><span class="n">random_state</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">imp_mean</span><span class="o">.</span><span class="n">fit</span><span class="p">([[</span><span class="mi">7</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">nan</span><span class="p">,</span> <span class="mi">6</span><span class="p">],</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">9</span><span class="p">]])</span>
<span class="go">IterativeImputer(random_state=0)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">X</span> <span class="o">=</span> <span class="p">[[</span><span class="n">np</span><span class="o">.</span><span class="n">nan</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">nan</span><span class="p">,</span> <span class="mi">6</span><span class="p">],</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">nan</span><span class="p">,</span> <span class="mi">9</span><span class="p">]]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">imp_mean</span><span class="o">.</span><span class="n">transform</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="go">array([[ 6.9584...,  2.       ,  3.        ],</span>
<span class="go">       [ 4.       ,  2.6000...,  6.        ],</span>
<span class="go">       [10.       ,  4.9999...,  9.        ]])</span>
</pre></div>
</div>
<p class="rubric">Methods</p>
<table class="longtable docutils align-default">
<colgroup>
<col style="width: 10%" />
<col style="width: 90%" />
</colgroup>
<tbody>
<tr class="row-odd"><td><p><a class="reference internal" href="#sklearn.impute.IterativeImputer.fit" title="sklearn.impute.IterativeImputer.fit"><code class="xref py py-obj docutils literal notranslate"><span class="pre">fit</span></code></a>(self, X[, y])</p></td>
<td><p>Fits the imputer on X and return self.</p></td>
</tr>
<tr class="row-even"><td><p><a class="reference internal" href="#sklearn.impute.IterativeImputer.fit_transform" title="sklearn.impute.IterativeImputer.fit_transform"><code class="xref py py-obj docutils literal notranslate"><span class="pre">fit_transform</span></code></a>(self, X[, y])</p></td>
<td><p>Fits the imputer on X and return the transformed X.</p></td>
</tr>
<tr class="row-odd"><td><p><a class="reference internal" href="#sklearn.impute.IterativeImputer.get_params" title="sklearn.impute.IterativeImputer.get_params"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_params</span></code></a>(self[, deep])</p></td>
<td><p>Get parameters for this estimator.</p></td>
</tr>
<tr class="row-even"><td><p><a class="reference internal" href="#sklearn.impute.IterativeImputer.set_params" title="sklearn.impute.IterativeImputer.set_params"><code class="xref py py-obj docutils literal notranslate"><span class="pre">set_params</span></code></a>(self, \*\*params)</p></td>
<td><p>Set the parameters of this estimator.</p></td>
</tr>
<tr class="row-odd"><td><p><a class="reference internal" href="#sklearn.impute.IterativeImputer.transform" title="sklearn.impute.IterativeImputer.transform"><code class="xref py py-obj docutils literal notranslate"><span class="pre">transform</span></code></a>(self, X)</p></td>
<td><p>Imputes all missing values in X.</p></td>
</tr>
</tbody>
</table>
<dl class="method">
<dt id="sklearn.impute.IterativeImputer.__init__">
<code class="sig-name descname">__init__</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">estimator=None</em>, <em class="sig-param">missing_values=nan</em>, <em class="sig-param">sample_posterior=False</em>, <em class="sig-param">max_iter=10</em>, <em class="sig-param">tol=0.001</em>, <em class="sig-param">n_nearest_features=None</em>, <em class="sig-param">initial_strategy='mean'</em>, <em class="sig-param">imputation_order='ascending'</em>, <em class="sig-param">skip_complete=False</em>, <em class="sig-param">min_value=None</em>, <em class="sig-param">max_value=None</em>, <em class="sig-param">verbose=0</em>, <em class="sig-param">random_state=None</em>, <em class="sig-param">add_indicator=False</em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/scikit-learn/scikit-learn/blob/5f3c3f037/sklearn/impute/_iterative.py#L208"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#sklearn.impute.IterativeImputer.__init__" title="Permalink to this definition">¶</a></dt>
<dd><p>Initialize self.  See help(type(self)) for accurate signature.</p>
</dd></dl>

<dl class="method">
<dt id="sklearn.impute.IterativeImputer.fit">
<code class="sig-name descname">fit</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">X</em>, <em class="sig-param">y=None</em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/scikit-learn/scikit-learn/blob/5f3c3f037/sklearn/impute/_iterative.py#L692"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#sklearn.impute.IterativeImputer.fit" title="Permalink to this definition">¶</a></dt>
<dd><p>Fits the imputer on X and return self.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><dl class="simple">
<dt><strong>X</strong><span class="classifier">array-like, shape (n_samples, n_features)</span></dt><dd><p>Input data, where “n_samples” is the number of samples and
“n_features” is the number of features.</p>
</dd>
<dt><strong>y</strong><span class="classifier">ignored</span></dt><dd></dd>
</dl>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><dl class="simple">
<dt><strong>self</strong><span class="classifier">object</span></dt><dd><p>Returns self.</p>
</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="sklearn.impute.IterativeImputer.fit_transform">
<code class="sig-name descname">fit_transform</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">X</em>, <em class="sig-param">y=None</em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/scikit-learn/scikit-learn/blob/5f3c3f037/sklearn/impute/_iterative.py#L525"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#sklearn.impute.IterativeImputer.fit_transform" title="Permalink to this definition">¶</a></dt>
<dd><p>Fits the imputer on X and return the transformed X.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><dl class="simple">
<dt><strong>X</strong><span class="classifier">array-like, shape (n_samples, n_features)</span></dt><dd><p>Input data, where “n_samples” is the number of samples and
“n_features” is the number of features.</p>
</dd>
<dt><strong>y</strong><span class="classifier">ignored.</span></dt><dd></dd>
</dl>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><dl class="simple">
<dt><strong>Xt</strong><span class="classifier">array-like, shape (n_samples, n_features)</span></dt><dd><p>The imputed input data.</p>
</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="sklearn.impute.IterativeImputer.get_params">
<code class="sig-name descname">get_params</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">deep=True</em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/scikit-learn/scikit-learn/blob/5f3c3f037/sklearn/base.py#L173"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#sklearn.impute.IterativeImputer.get_params" title="Permalink to this definition">¶</a></dt>
<dd><p>Get parameters for this estimator.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><dl class="simple">
<dt><strong>deep</strong><span class="classifier">bool, default=True</span></dt><dd><p>If True, will return the parameters for this estimator and
contained subobjects that are estimators.</p>
</dd>
</dl>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><dl class="simple">
<dt><strong>params</strong><span class="classifier">mapping of string to any</span></dt><dd><p>Parameter names mapped to their values.</p>
</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="sklearn.impute.IterativeImputer.set_params">
<code class="sig-name descname">set_params</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">**params</em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/scikit-learn/scikit-learn/blob/5f3c3f037/sklearn/base.py#L205"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#sklearn.impute.IterativeImputer.set_params" title="Permalink to this definition">¶</a></dt>
<dd><p>Set the parameters of this estimator.</p>
<p>The method works on simple estimators as well as on nested objects
(such as pipelines). The latter have parameters of the form
<code class="docutils literal notranslate"><span class="pre">&lt;component&gt;__&lt;parameter&gt;</span></code> so that it’s possible to update each
component of a nested object.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><dl class="simple">
<dt><strong>**params</strong><span class="classifier">dict</span></dt><dd><p>Estimator parameters.</p>
</dd>
</dl>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><dl class="simple">
<dt><strong>self</strong><span class="classifier">object</span></dt><dd><p>Estimator instance.</p>
</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="sklearn.impute.IterativeImputer.transform">
<code class="sig-name descname">transform</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">X</em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/scikit-learn/scikit-learn/blob/5f3c3f037/sklearn/impute/_iterative.py#L642"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#sklearn.impute.IterativeImputer.transform" title="Permalink to this definition">¶</a></dt>
<dd><p>Imputes all missing values in X.</p>
<p>Note that this is stochastic, and that if random_state is not fixed,
repeated calls, or permuted input, will yield different results.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><dl class="simple">
<dt><strong>X</strong><span class="classifier">array-like of shape (n_samples, n_features)</span></dt><dd><p>The input data to complete.</p>
</dd>
</dl>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><dl class="simple">
<dt><strong>Xt</strong><span class="classifier">array-like, shape (n_samples, n_features)</span></dt><dd><p>The imputed input data.</p>
</dd>
</dl>
</dd>
</dl>
</dd></dl>

</dd></dl>

<div class="section" id="examples-using-sklearn-impute-iterativeimputer">
<h2>Examples using <code class="docutils literal notranslate"><span class="pre">sklearn.impute.IterativeImputer</span></code><a class="headerlink" href="#examples-using-sklearn-impute-iterativeimputer" title="Permalink to this headline">¶</a></h2>
<div class="sphx-glr-thumbcontainer" tooltip="The sklearn.impute.IterativeImputer class is very flexible - it can be used with a variety of e..."><div class="figure align-default" id="id3">
<img alt="../../_images/sphx_glr_plot_iterative_imputer_variants_comparison_thumb.png" src="../../_images/sphx_glr_plot_iterative_imputer_variants_comparison_thumb.png" />
<p class="caption"><span class="caption-text"><a class="reference internal" href="../../auto_examples/impute/plot_iterative_imputer_variants_comparison.html#sphx-glr-auto-examples-impute-plot-iterative-imputer-variants-comparison-py"><span class="std std-ref">Imputing missing values with variants of IterativeImputer</span></a></span><a class="headerlink" href="#id3" title="Permalink to this image">¶</a></p>
</div>
</div><div class="sphx-glr-thumbcontainer" tooltip="Missing values can be replaced by the mean, the median or the most frequent value using the bas..."><div class="figure align-default" id="id4">
<img alt="../../_images/sphx_glr_plot_missing_values_thumb.png" src="../../_images/sphx_glr_plot_missing_values_thumb.png" />
<p class="caption"><span class="caption-text"><a class="reference internal" href="../../auto_examples/impute/plot_missing_values.html#sphx-glr-auto-examples-impute-plot-missing-values-py"><span class="std std-ref">Imputing missing values before building an estimator</span></a></span><a class="headerlink" href="#id4" title="Permalink to this image">¶</a></p>
</div>
</div><div class="clearer"></div></div>
</div>


      </div>
    <div class="container">
      <footer class="sk-content-footer">
            &copy; 2007 - 2019, scikit-learn developers (BSD License).
          <a href="../../_sources/modules/generated/sklearn.impute.IterativeImputer.rst.txt" rel="nofollow">Show this page source</a>
      </footer>
    </div>
  </div>
</div>
<script src="../../_static/js/vendor/bootstrap.min.js"></script>

<script>
    window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
    ga('create', 'UA-22606712-2', 'auto');
    ga('set', 'anonymizeIp', true);
    ga('send', 'pageview');
</script>
<script async src='https://www.google-analytics.com/analytics.js'></script>


<script>
$(document).ready(function() {
    /* Add a [>>>] button on the top-right corner of code samples to hide
     * the >>> and ... prompts and the output and thus make the code
     * copyable. */
    var div = $('.highlight-python .highlight,' +
                '.highlight-python3 .highlight,' +
                '.highlight-pycon .highlight,' +
		'.highlight-default .highlight')
    var pre = div.find('pre');

    // get the styles from the current theme
    pre.parent().parent().css('position', 'relative');
    var hide_text = 'Hide prompts and outputs';
    var show_text = 'Show prompts and outputs';

    // create and add the button to all the code blocks that contain >>>
    div.each(function(index) {
        var jthis = $(this);
        if (jthis.find('.gp').length > 0) {
            var button = $('<span class="copybutton">&gt;&gt;&gt;</span>');
            button.attr('title', hide_text);
            button.data('hidden', 'false');
            jthis.prepend(button);
        }
        // tracebacks (.gt) contain bare text elements that need to be
        // wrapped in a span to work with .nextUntil() (see later)
        jthis.find('pre:has(.gt)').contents().filter(function() {
            return ((this.nodeType == 3) && (this.data.trim().length > 0));
        }).wrap('<span>');
    });

    // define the behavior of the button when it's clicked
    $('.copybutton').click(function(e){
        e.preventDefault();
        var button = $(this);
        if (button.data('hidden') === 'false') {
            // hide the code output
            button.parent().find('.go, .gp, .gt').hide();
            button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'hidden');
            button.css('text-decoration', 'line-through');
            button.attr('title', show_text);
            button.data('hidden', 'true');
        } else {
            // show the code output
            button.parent().find('.go, .gp, .gt').show();
            button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'visible');
            button.css('text-decoration', 'none');
            button.attr('title', hide_text);
            button.data('hidden', 'false');
        }
    });

	/*** Add permalink buttons next to glossary terms ***/
	$('dl.glossary > dt[id]').append(function() {
		return ('<a class="headerlink" href="#' +
			    this.getAttribute('id') +
			    '" title="Permalink to this term">¶</a>');
	});
  /*** Hide navbar when scrolling down ***/
  // Returns true when headerlink target matches hash in url
  (function() {
    hashTargetOnTop = function() {
        var hash = window.location.hash;
        if ( hash.length < 2 ) { return false; }

        var target = document.getElementById( hash.slice(1) );
        if ( target === null ) { return false; }

        var top = target.getBoundingClientRect().top;
        return (top < 2) && (top > -2);
    };

    // Hide navbar on load if hash target is on top
    var navBar = document.getElementById("navbar");
    var navBarToggler = document.getElementById("sk-navbar-toggler");
    var navBarHeightHidden = "-" + navBar.getBoundingClientRect().height + "px";
    var $window = $(window);

    hideNavBar = function() {
        navBar.style.top = navBarHeightHidden;
    };

    showNavBar = function() {
        navBar.style.top = "0";
    }

    if (hashTargetOnTop()) {
        hideNavBar()
    }

    var prevScrollpos = window.pageYOffset;
    hideOnScroll = function(lastScrollTop) {
        if (($window.width() < 768) && (navBarToggler.getAttribute("aria-expanded") === 'true')) {
            return;
        }
        if (lastScrollTop > 2 && (prevScrollpos <= lastScrollTop) || hashTargetOnTop()){
            hideNavBar()
        } else {
            showNavBar()
        }
        prevScrollpos = lastScrollTop;
    };

    /*** high preformance scroll event listener***/
    var raf = window.requestAnimationFrame ||
        window.webkitRequestAnimationFrame ||
        window.mozRequestAnimationFrame ||
        window.msRequestAnimationFrame ||
        window.oRequestAnimationFrame;
    var lastScrollTop = $window.scrollTop();

    if (raf) {
        loop();
    }

    function loop() {
        var scrollTop = $window.scrollTop();
        if (lastScrollTop === scrollTop) {
            raf(loop);
            return;
        } else {
            lastScrollTop = scrollTop;
            hideOnScroll(lastScrollTop);
            raf(loop);
        }
    }
  })();
});

</script>
    
<script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml.js"></script>
    
</body>
</html>